import java.util.*;

public class Question2 {
	static int n;
	static int m;
	static int k;

	// startPoint和finishPoint 保存开始和结束的坐标
	static int[] startPoint;
	static int[] finishPoint;

	// 保存输入数组
	static int[][] table;

	// 记忆化
	// tmp[x1][y1] 对应 solveProblem(x1, y1, x2, y2)
	static int[][] tmp;

	// 保存已经走过的路径,防止走已经走过的点
	static boolean[][] visitedPoints;

	// 使用静态Scanner方便主函数和函数中调用
	static Scanner input = new Scanner(System.in);

	public static void main(String[] args) {

		// 输入数据
		getInput();

		// 输出数据
		// print();

		// 首先设置开始的起点是已经走过的点
		visitedPoints[startPoint[0]][startPoint[1]] = true;

		// 调用solveProblem函数,得到最终答案
		System.out.println(solveProblem(startPoint[0], startPoint[1], finishPoint[0], finishPoint[1]));
		input.close();
	}

	// 判断x,y这个点是否可以到达,x1,y1为现在所在的点,j为跨越的距离
	static boolean canReach(int x, int y, int x1, int y1, int j) {

		// x < m && y < n && x >= 0 && y >= 0 判断是否超出边界
		// table[x][y] == 0 判断该点是否是空格
		// !visitedPoints[x][y] 判断该点是否之前已经走过
		if (x < m && y < n && x >= 0 && y >= 0 && table[x][y] == 0 && !visitedPoints[x][y]) {

			// 距离为1也就是x1 y1周围一圈的点,可以到达
			if (j == 1) {
				return true;
			}

			else {
				// 创建一个二维数组保存x,y和x1,y1之间的点
				int[][] points = new int[j - 1][2];

				// 计算points数组中的坐标值
				// 举例说明x,y为(1,1) x1,y1为(5,5) j为4
				// points.length就是3
				for (int i = 0; i < points.length; i++) {

					// 计算x
					if (x != x1) {

						// 举例说明:
						// x,y为(1,1) x1,y1为(5,5)

						// 当i为0的时候:
						// points[0][0]就为 2

						// 当i为1的时候:
						// points[1][0]就为 3
						points[i][0] = x > x1 ? x1 + (i + 1) : x1 - (i + 1);
					}

					else {
						points[i][0] = x;
					}

					if (y != y1) {
						points[i][1] = y > y1 ? y1 + i + 1 : y1 - (i + 1);
					}

					else {
						points[i][1] = y;
					}
				}

				// 遍历判断points中的坐标是否都是block cell,如果不是则返回false
				for (int i = 0; i < points.length; i++) {
					if (table[points[i][0]][points[i][1]] != 1) {
						return false;
					}
				}

				return true;
			}
		}

		return false;
	}

	static int solveProblem(int x1, int y1, int x2, int y2) {

		// 中止条件:当前坐标等于目的坐标
		if (x1 == x2 && y1 == y2) {
			return 0;
		}

		else {
			// 如果没有计算过solveProblem(x1, y1, x2, y2),则开始处理
			if (tmp[x1][y1] == 0) {
				// 保存不同方案中的最小值
				// 取个极大值保证 Math.min()时取到正确的值,而不是0
				int re = Integer.MAX_VALUE / 2;

				// directions用于保存下一步移动的方向,与question1不一样的地方在于:
				// 不是 {必须要走 [靠近目的点] 的路径}
				// 因此要遍历所有的方向情况
				int[][] directions = {
						{ 1, 0 },
						{ -1, 0 },
						{ 0, 1 },
						{ 0, -1 },
						{ 1, 1 },
						{ -1, -1 },
						{ -1, 1 },
						{ 1, -1 },
				};

				// 遍历所有方向
				for (int i = 0; i < directions.length; i++) {

					// k的定义是可以最多跨过的 block cell,
					// j定义为是离当前多远的格子
					// 因此 当k等于0时,j等于1
					// 当k等于1时,j可以等于1或者2
					// 所以使用遍历,得到所有j的取值情况
					for (int j = 1; j < k + 2; j++) {

						// 得到新坐标
						int newX = x1 + directions[i][0] * j;
						int newY = y1 + directions[i][1] * j;

						// 如果newX,newY是可以到达的
						if (canReach(newX, newY, x1, y1, j)) {

							// 将newX, newY设置为已经走过的点
							visitedPoints[newX][newY] = true;

							// 再递归调用solveProblem(),处理下一步
							re = Math.min(re, 1 + solveProblem(newX, newY, x2, y2));

							// 尝试了newX, newY点后 将newX, newY设置为没走过的点
							visitedPoints[newX][newY] = false;
						}
					}

				}
				// System.out.println(re);
				// 将最终结果保存到tmp中
				tmp[x1][y1] = re;

			}
			// 返回最终结果
			return tmp[x1][y1];
		}

	}

	// 同question1的getInput,只是多了一个k
	static void getInput() {
		int i;
		int j;

		n = input.nextInt();
		m = input.nextInt();
		input.nextLine();
		String s = input.nextLine();
		k = input.nextInt();

		table = new int[m][n];
		tmp = new int[m][n];
		visitedPoints = new boolean[m][n];
		startPoint = new int[2];
		finishPoint = new int[2];

		for (i = 0; i < m; i++) {
			for (j = 0; j < n; j++) {
				table[i][j] = input.nextInt();
			}
		}

		s = s.replace(" ", "");
		s = s.substring(1, s.length() - 1);

		String[] pointString = s.split("\\)\\(");

		for (i = 0; i < 2; i++) {
			startPoint[i] = Integer.parseInt(pointString[0].split(",")[1 - i]) - 1;
			finishPoint[i] = Integer.parseInt(pointString[1].split(",")[1 - i]) - 1;
		}
	}

	static void print() {
		System.out.println();
		int i;
		int j;

		System.out.println(startPoint[0] + " " + startPoint[1]);
		System.out.println(finishPoint[0] + " " + finishPoint[1]);
		System.out.println(k);
		for (i = 0; i < m; i++) {
			for (j = 0; j < n; j++) {
				System.out.print(table[i][j] + " ");
			}
			System.out.println();
		}

	}
}